home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 6: Level 6 / 17 Bit - Level 6 (1998)(Epic Marketing)[!].iso / quartz / q1082.dms / q1082.adf / src.lzh / Fig / ruler.c < prev    next >
C/C++ Source or Header  |  1991-07-18  |  18KB  |  659 lines
  1. /* 
  2.  *    FIG : Facility for Interactive Generation of figures
  3.  *
  4.  *    Copyright (c) 1985 by Supoj Sutanthavibul (supoj@sally.UTEXAS.EDU)
  5.  *    January 1985.
  6.  *    1st revision : Aug 1985.
  7.  *
  8.  *    %W%    %G%
  9. */
  10. #include "fig.h"
  11. #include "resources.h"
  12. #include "const.h"
  13. #include "font.h"
  14. #include "paintop.h"
  15.  
  16. #define            INCH_MARK        12
  17. #define            HALF_MARK        11
  18. #define            QUARTER_MARK        8
  19. #define            SIXTEENTH_MARK        6
  20.  
  21. #ifndef    X11
  22. #define            MARK_HT            5
  23. #define            TRM_WID            15
  24. #define            TRM_HT            8
  25. #define            SRM_WID            8
  26. #define            SRM_HT            15
  27. #else
  28. #define            MARK_HT            5
  29. #define            TRM_WID            16
  30. #define            TRM_HT            8
  31. #define            SRM_WID            8
  32. #define            SRM_HT            16
  33. #endif
  34.  
  35. extern int        CANVAS_HEIGHT, CANVAS_WIDTH;
  36. extern int        SIDERULER_WIDTH, SIDERULER_HEIGHT;
  37. extern int        TOPRULER_WIDTH, TOPRULER_HEIGHT;
  38. extern int        SIDERULER_HEIGHT, SIDERULER_START;
  39. extern int        TOPRULER_LEFT, TOPRULER_TOP;
  40. extern            null_proc();
  41. extern int        RHS_PANEL;
  42. extern int        TRACKING;
  43.  
  44. static            lasty = -100;
  45. static            lastx = -100;
  46. static int         start;
  47. static char        *number[] = {"0", "1", "2", "3", "4", "5", 
  48.                     "6", "7", "8", "9", "10", "11" };
  49. static int        troffx = -7, troffy = -10;
  50. #ifndef    X11
  51. static short        tr_marker_image[8] = {
  52.                 0xFFFE,    /* *************** */
  53.                 0x7FFC,    /*  *************  */
  54.                 0x3FF8,    /*   ***********   */
  55.                 0x1FF0,    /*    *********    */
  56.                 0x0FE0,    /*     *******     */
  57.                 0x07C0,    /*      *****      */
  58.                 0x0380,    /*       ***       */
  59.                 0x0100    /*        *        */
  60.                 };
  61. #else
  62. static char        tr_marker_image[16] = {
  63.                 0xFF, 0xFE,    /* *************** */
  64.                 0x7F, 0xFC,    /*  *************  */
  65.                 0x3F, 0xF8,    /*   ***********   */
  66.                 0x1F, 0xF0,    /*    *********    */
  67.                 0x0F, 0xE0,    /*     *******     */
  68.                 0x07, 0xC0,    /*      *****      */
  69.                 0x03, 0x80,    /*       ***       */
  70.                 0x01, 0x00    /*        *        */
  71.                 };
  72. #endif
  73. static            mpr_static(trm_pr, TRM_WID, TRM_HT, 1, tr_marker_image);
  74. static int        srroffx = 2, srroffy = -7;
  75. #ifndef    X11
  76. static short        srr_marker_image[15] = {
  77.                 0x0100,    /*          *  */
  78.                 0x0300,    /*         **  */
  79.                 0x0700,    /*        ***  */
  80.                 0x0F00,    /*       ****  */
  81.                 0x1F00,    /*      *****  */
  82.                 0x3F00,    /*     ******  */
  83.                 0x7F00,    /*    *******  */
  84.                 0xFF00, /*   ********  */
  85.                 0x7F00,    /*    *******  */
  86.                 0x3F00,    /*     ******  */
  87.                 0x1F00,    /*      *****  */
  88.                 0x0F00,    /*       ****  */
  89.                 0x0700,    /*        ***  */
  90.                 0x0300,    /*         **  */
  91.                 0x0100    /*          *  */
  92.                 };
  93. #else
  94. static char        srr_marker_image[16] = {
  95.                 0x01,    /*          *  */
  96.                 0x03,    /*         **  */
  97.                 0x07,    /*        ***  */
  98.                 0x0F,    /*       ****  */
  99.                 0x1F,    /*      *****  */
  100.                 0x3F,    /*     ******  */
  101.                 0x7F,    /*    *******  */
  102.                 0xFF,    /*   ********  */
  103.                 0x7F,    /*    *******  */
  104.                 0x3F,    /*     ******  */
  105.                 0x1F,    /*      *****  */
  106.                 0x0F,    /*       ****  */
  107.                 0x07,    /*        ***  */
  108.                 0x03,    /*         **  */
  109.                 0x01,    /*          *  */
  110.                 0x00
  111.                 };
  112. #endif
  113. static        mpr_static(srrm_pr, SRM_WID, SRM_HT, 1, srr_marker_image);
  114.  
  115. static int        srloffx = -10, srloffy = -7;
  116. #ifndef    X11
  117. static short        srl_marker_image[15] = {
  118.                 0x8000,    /*  *          */
  119.                 0xC000,    /*  **         */
  120.                 0xE000,    /*  ***        */
  121.                 0xF000,    /*  ****       */
  122.                 0xF800,    /*  *****      */
  123.                 0xFC00,    /*  ******     */
  124.                 0xFE00,    /*  *******    */
  125.                 0xFF00,    /*  ********   */
  126.                 0xFE00,    /*  *******    */
  127.                 0xFC00,    /*  ******     */
  128.                 0xF800,    /*  *****      */
  129.                 0xF000,    /*  ****       */
  130.                 0xE000,    /*  ***        */
  131.                 0xC000,    /*  **         */
  132.                 0x8000    /*  *          */
  133.                 };
  134. #else
  135. static char        srl_marker_image[16] = {
  136.                 0x80,    /*  *          */
  137.                 0xC0,    /*  **         */
  138.                 0xE0,    /*  ***        */
  139.                 0xF0,    /*  ****       */
  140.                 0xF8,    /*  *****      */
  141.                 0xFC,    /*  ******     */
  142.                 0xFE,    /*  *******    */
  143.                 0xFF,    /*  ********   */
  144.                 0xFE,    /*  *******    */
  145.                 0xFC,    /*  ******     */
  146.                 0xF8,    /*  *****      */
  147.                 0xF0,    /*  ****       */
  148.                 0xE0,    /*  ***        */
  149.                 0xC0,    /*  **         */
  150.                 0x80,    /*  *          */
  151.                 0x00
  152.                 };
  153. #endif
  154. static        mpr_static(srlm_pr, SRM_WID, SRM_HT, 1, srl_marker_image);
  155.  
  156. #ifdef    X11
  157. static Pixmap        toparrow_pm, sidearrow_pm;
  158. #endif
  159.  
  160. set_toprulermark(x)
  161. int    x;
  162. {
  163. #ifndef    X11
  164.     pw_write(topruler_pixwin, lastx + troffx, RULER_WIDTH + troffy, 
  165.         TRM_WID, TRM_HT, INV_PAINT, &trm_pr, 0, 0);
  166.     pw_write(topruler_pixwin, x + troffx, RULER_WIDTH + troffy, 
  167.         TRM_WID, TRM_HT, INV_PAINT, &trm_pr, 0, 0);
  168. #else
  169.     XClearArea(tool_d, topruler_pixwin,lastx + troffx,
  170.            TOPRULER_HEIGHT + troffy,trm_pr.width,
  171.            trm_pr.height, False);
  172.     XCopyArea(tool_d, toparrow_pm, topruler_pixwin, topgc,
  173.         0, 0, trm_pr.width, trm_pr.height,
  174.         x + troffx, TOPRULER_HEIGHT + troffy);
  175. #endif    X11
  176.     lastx = x;
  177.     }
  178.  
  179. #ifndef    X11
  180. #ifdef AMIGA
  181. #else
  182. static
  183. sideruler_sighandler()
  184. {
  185.     pw_damaged(sideruler_pixwin);
  186.     pw_repairretained(sideruler_pixwin);
  187.     pw_donedamaged(sideruler_pixwin);
  188.     }
  189.  
  190. static
  191. flush_input(nullsw, ibits, obits, ebits, timer)
  192. caddr_t        nullsw;
  193. int        *ibits, *obits, *ebits;
  194. struct timeval    *timer;
  195. {
  196.     INPUTEVENT        ie;
  197.  
  198.     (void)input_readevent(srswfd, &ie);
  199.     *ibits = *obits = *ebits = 0;
  200.     }
  201.  
  202.  
  203. int
  204. init_sideruler(tool)
  205. TOOL        tool;
  206. {
  207.     INPUTMASK        mask;
  208.  
  209.     sideruler_sw = tool_createsubwindow(tool, "side ruler", 
  210.                 SIDERULER_WIDTH, SIDERULER_HEIGHT);
  211.     if (sideruler_sw == (TOOLSW)0) return(0);
  212.     (int) sideruler_sw->ts_data = srswfd = sideruler_sw->ts_windowfd;
  213.  
  214.     sideruler_pixwin = pw_open(srswfd);
  215.     sideruler_pixwin->pw_prretained = mem_create(SIDERULER_WIDTH, 
  216.                         SIDERULER_HEIGHT, 1);
  217.     input_imnull(&mask);
  218.     win_setinputcodebit(&mask, MS_RIGHT);
  219.     /* Pass input events other than right mouse to parent window */
  220.     win_setinputmask(srswfd, &mask, NULL, WIN_NULLLINK);
  221.     win_setcursor(srswfd, &bull_cursor);
  222.     sideruler_sw->ts_io.tio_selected = flush_input;
  223.     sideruler_sw->ts_io.tio_handlesigwinch = sideruler_sighandler;
  224.     sideruler_sw->ts_destroy = null_proc;
  225.  
  226.     show_sideruler();
  227.     return(1);
  228.     }
  229. #endif AMIGA
  230. #else
  231. static Arg    ruler_args[] =
  232. {
  233.     { XtNx, (XtArgVal)0 },
  234.     { XtNy, (XtArgVal)0 },
  235.     { XtNwidth, (XtArgVal)0 },
  236.     { XtNheight, (XtArgVal)0 },
  237.     { XtNlabel, (XtArgVal)"" },
  238.     { XtNfromHoriz, (XtArgVal)NULL },
  239.     { XtNhorizDistance, (XtArgVal)0 },
  240.     { XtNfromVert, (XtArgVal)NULL },
  241.     { XtNvertDistance, (XtArgVal)0 },
  242.     { XtNresizable, (XtArgVal)FALSE },
  243.     { XtNtop, (XtArgVal)XtRubber },
  244.     { XtNbottom, (XtArgVal)XtRubber },
  245.     { XtNleft, (XtArgVal)XtRubber },
  246.     { XtNright, (XtArgVal)XtRubber },
  247. };
  248.  
  249. extern int    SIDERULER_WIDTH, SIDERULER_HEIGHT;
  250. extern int    TOPRULER_WIDTH, TOPRULER_HEIGHT;
  251.  
  252. int init_sideruler(tool)
  253.     TOOL        tool;
  254. {
  255.     ruler_args[2].value = SIDERULER_WIDTH = RULER_WIDTH;
  256.     ruler_args[3].value = SIDERULER_HEIGHT = CANVAS_HEIGHT;
  257.     ruler_args[5].value = (XtArgVal)canvas_sw;
  258.     ruler_args[7].value = (XtArgVal)topruler_sw;
  259.     /* Place the sideruler below the topruler, next to the canvas,
  260.        but fixed offset from the top of the form */
  261.     ruler_args[10].value = (XtArgVal)XtChainTop;
  262.     ruler_args[11].value = (XtArgVal)XtRubber;
  263.     ruler_args[12].value = (XtArgVal)XtRubber;
  264.     ruler_args[13].value = (XtArgVal)XtRubber;
  265.     
  266.     sideruler_sw = XtCreateWidget("sruler", labelWidgetClass, tool,
  267.         ruler_args, XtNumber(ruler_args));
  268.     return(1);
  269. }
  270.  
  271. redisplay_sideruler()
  272. {
  273.     XClearWindow(tool_d, sideruler_pixwin);
  274. }
  275.  
  276. setup_rulers()
  277. {
  278.     register int        i, j;
  279.     register Pixmap        p;
  280. #define    QINCH    (PIX_PER_INCH / 4)
  281. #define    SINCH    (PIX_PER_INCH / 16)
  282.     char            number[3];
  283.     Arg            tmp_arg[3];
  284.     long            bg, fg;
  285.     static Arg        ruler_args[] =
  286.     {
  287.         { XtNbackgroundPixmap, (XtArgVal)NULL },
  288.     };
  289.  
  290.     topruler_pixwin = trswfd = XtWindow(topruler_sw);
  291.     sideruler_pixwin = srswfd = XtWindow(sideruler_sw);
  292.     XDefineCursor(tool_d, trswfd, (Cursor)bull_cursor.bitmap);
  293.     XDefineCursor(tool_d, srswfd, (Cursor)bull_cursor.bitmap);
  294.  
  295.     /* top ruler, adjustments for digits are kludges based on 6x13 char */
  296.     p = XCreatePixmap(tool_d, topruler_pixwin,
  297.               TOPRULER_WIDTH, TOPRULER_HEIGHT,
  298.               DefaultDepthOfScreen(tool_s));
  299.  
  300.     XtSetArg(tmp_arg[0], XtNbackground, &bg);
  301.     XtSetArg(tmp_arg[1], XtNforeground, &fg);
  302.     XtGetValues(topruler_sw, tmp_arg, 2);
  303.  
  304.     XSetBackground(tool_d, gc, bg);
  305.     XSetForeground(tool_d, gc, bg);
  306.     XFillRectangle(tool_d, p, gc, 0, 0, TOPRULER_WIDTH,
  307.             TOPRULER_HEIGHT);
  308.     XSetForeground(tool_d, gc, fg);
  309.     
  310.     for (i = SINCH - 1; i <= TOPRULER_WIDTH; i += SINCH)
  311.     {
  312.         j = i + 1;
  313.         if (j % PIX_PER_INCH == 0)
  314.         {
  315.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  316.                 TOPRULER_HEIGHT - INCH_MARK - 1);
  317.             sprintf(number, "%d", j / PIX_PER_INCH);
  318.             XDrawString(tool_d, p, gc, i - 2,
  319.                 TOPRULER_HEIGHT - INCH_MARK - 3, number,
  320.                 j < PIX_PER_INCH * 10 ? 1 : 2);
  321.         }
  322.         else if (j % QINCH == 0)
  323.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  324.                 TOPRULER_HEIGHT - QUARTER_MARK - 1);
  325.         else if (j % SINCH == 0)
  326.             XDrawLine(tool_d, p, gc, i, TOPRULER_HEIGHT - 1, i,
  327.                 TOPRULER_HEIGHT - SIXTEENTH_MARK - 1);
  328.     }
  329.     ruler_args[0].value = (XtArgVal)p;
  330.     XtSetValues(topruler_sw, ruler_args, 1);
  331.  
  332.     /* The arrows will be XORed into the rulers.
  333.        We want the foreground color in the arrow to result in
  334.        the foreground or background color in the display.
  335.        so if the source pixel is fg^bg, it produces fg when XOR'ed
  336.        with bg, and bg when XOR'ed with bg.
  337.  
  338.        If the source pixel is zero, it produces fg when XOR'ed with
  339.        fg, and bg when XOR'ed with bg.
  340.        */
  341.     XSetForeground(tool_d, gc, fg ^ bg);
  342.     XSetBackground(tool_d, gc, 0);
  343.  
  344.     /* make pixmaps for top ruler arrow */
  345.     toparrow_pm = XCreatePixmap(tool_d, topruler_pixwin, trm_pr.width,
  346.                     trm_pr.height,
  347.                     DefaultDepthOfScreen(tool_s));
  348.     XPutImage(tool_d, toparrow_pm, gc, &trm_pr, 0, 0, 0, 0,
  349.         trm_pr.width, trm_pr.height);
  350.     
  351.     /* side ruler, adjustments for digits are kludges based on 6x13 char */
  352.     p = XCreatePixmap(tool_d, sideruler_pixwin,
  353.               SIDERULER_WIDTH, SIDERULER_HEIGHT,
  354.               DefaultDepthOfScreen(tool_s));
  355.     XtSetArg(tmp_arg[0], XtNbackground, &bg);
  356.     XtSetArg(tmp_arg[1], XtNforeground, &fg);
  357.     XtGetValues(sideruler_sw, tmp_arg, 2);
  358.  
  359.     XSetBackground(tool_d, gc, bg);
  360.     XSetForeground(tool_d, gc, bg);
  361.     XFillRectangle(tool_d, p, gc, 0, 0, SIDERULER_WIDTH,
  362.             SIDERULER_HEIGHT);
  363.     XSetForeground(tool_d, gc, fg);
  364.     
  365.     if( RHS_PANEL )
  366.     {
  367.         for (i = SINCH - 1; i <= SIDERULER_HEIGHT; i += SINCH)
  368.         {
  369.             j = i + 1;
  370.             if (j % PIX_PER_INCH == 0)
  371.             {
  372.                 XDrawLine(tool_d, p, gc, RULER_WIDTH-INCH_MARK,
  373.                       i, RULER_WIDTH, i);
  374.                 sprintf(number, "%d", j / PIX_PER_INCH);
  375.                 XDrawString(tool_d, p, gc,
  376.                         RULER_WIDTH-INCH_MARK - 8, i + 3,
  377.                         number, j < PIX_PER_INCH * 10 ? 1 : 2);
  378.             }
  379.             else if (j % QINCH == 0)
  380.                 XDrawLine(tool_d, p, gc,
  381.                       RULER_WIDTH-QUARTER_MARK, i,
  382.                       RULER_WIDTH, i);
  383.             else if (j % SINCH == 0)
  384.                 XDrawLine(tool_d, p, gc,
  385.                       RULER_WIDTH-SIXTEENTH_MARK, i,
  386.                       RULER_WIDTH, i);
  387.         }
  388.     }
  389.     else
  390.     {
  391.         for (i = SINCH - 1; i <= SIDERULER_HEIGHT; i += SINCH)
  392.         {
  393.             j = i + 1;
  394.             if (j % PIX_PER_INCH == 0)
  395.             {
  396.                 XDrawLine(tool_d, p, gc, 0, i,
  397.                       INCH_MARK - 1, i);
  398.                 sprintf(number, "%d", j / PIX_PER_INCH);
  399.                 XDrawString(tool_d, p, gc, INCH_MARK + 3,
  400.                         i + 3, number,
  401.                         j < PIX_PER_INCH * 10 ? 1 : 2);
  402.             }    
  403.             else if (j % QINCH == 0)
  404.                 XDrawLine(tool_d, p, gc, 0, i,
  405.                       QUARTER_MARK - 1, i);
  406.             else if (j % SINCH == 0)
  407.                 XDrawLine(tool_d, p, gc, 0, i,
  408.                       SIXTEENTH_MARK - 1, i);
  409.         }    
  410.     }
  411.     ruler_args[0].value = (XtArgVal)p;
  412.     XtSetValues(sideruler_sw, ruler_args, 1);
  413.  
  414.     /* Colors set as above */
  415.     XSetForeground(tool_d, gc, fg ^ bg);
  416.     XSetBackground(tool_d, gc, 0);
  417.  
  418.     /* make pixmaps for side ruler arrow */
  419.     if( RHS_PANEL )
  420.     {
  421.         sidearrow_pm = XCreatePixmap(tool_d, sideruler_pixwin,
  422.                          srlm_pr.width, srlm_pr.height,
  423.                          DefaultDepthOfScreen(tool_s));
  424.         XPutImage(tool_d, sidearrow_pm, gc, &srlm_pr, 0, 0, 0, 0,
  425.               srlm_pr.width, srlm_pr.height);
  426.     }
  427.     else
  428.     {
  429.         sidearrow_pm = XCreatePixmap(tool_d, sideruler_pixwin,
  430.                          srrm_pr.width, srrm_pr.height,
  431.                          DefaultDepthOfScreen(tool_s));
  432.         XPutImage(tool_d, sidearrow_pm, gc, &srrm_pr, 0, 0, 0, 0,
  433.               srrm_pr.width, srrm_pr.height);
  434.     }
  435. }
  436. #endif    X11
  437.  
  438. #ifndef    X11
  439. #ifdef AMIGA
  440. #else
  441. show_sideruler()
  442. {
  443.     int     i, qinch, sinch, charht, charx, end;
  444.     char    **d;
  445.  
  446.     pw_writebackground(sideruler_pixwin, 0, 0, 2048, 2048, PAINT);
  447.     if (RHS_PANEL){
  448.         start = RULER_WIDTH;
  449.         charx = RULER_WIDTH - INCH_MARK - char_width(bold_font);
  450.         }
  451.     else {
  452.         start = 0;
  453.         charx = INCH_MARK + 2;
  454.         }
  455.  
  456.     charht = char_height(bold_font);
  457.     for (d = number, i = SIDERULER_START + charht / 2 - 3;
  458.         i < SIDERULER_HEIGHT; 
  459.         d++, i += PIX_PER_INCH) {
  460.         pw_text(sideruler_pixwin, charx, i, PAINT, bold_font, *d);
  461.         }
  462.     qinch = PIX_PER_INCH / 4;
  463.     sinch = PIX_PER_INCH / 16;
  464.     /*  Draw Scale  */
  465.     end = abs(start - INCH_MARK);
  466.     for (i = SIDERULER_START - 1; i < SIDERULER_HEIGHT; i += PIX_PER_INCH) 
  467.         pw_vector(sideruler_pixwin, start, i, end, i, PAINT, 1);
  468.     end = abs(start - HALF_MARK);
  469.     for (i = SIDERULER_START - 1 + PIX_PER_INCH / 2; 
  470.         i < SIDERULER_HEIGHT; i += PIX_PER_INCH)
  471.         pw_vector(sideruler_pixwin, start, i, end, i, PAINT, 1);
  472.     end = abs(start - QUARTER_MARK);
  473.     for (i = SIDERULER_START - 1; i < SIDERULER_HEIGHT; i += qinch)
  474.         pw_vector(sideruler_pixwin, start, i, end, i, PAINT, 1);
  475.     end = abs(start - SIXTEENTH_MARK);
  476.     for (i = SIDERULER_START - 1; i < SIDERULER_HEIGHT; i += sinch)
  477.         pw_vector(sideruler_pixwin, start, i, end, i, PAINT, 1);
  478.     /*  Darw marker  */
  479.     if (RHS_PANEL) { /*  side ruler is on the LSH of canvas */
  480.         pw_write(sideruler_pixwin, RULER_WIDTH+srloffx, lasty+srloffy, 
  481.             SRM_WID, SRM_HT, INV_PAINT, &srlm_pr, 0, 0);
  482.         }
  483.     else { /*  side ruler is on the RSH of canvas */
  484.         pw_write(sideruler_pixwin, srroffx, lasty+srroffy, 
  485.             SRM_WID, SRM_HT, INV_PAINT, &srrm_pr, 0, 0);
  486.         }
  487.     }
  488. #endif /* AMIGA */
  489. #endif    X11
  490.  
  491. #ifndef    X11
  492. #ifdef AMIGA
  493. #else
  494. static
  495. topruler_sighandler()
  496. {
  497.     pw_damaged(topruler_pixwin);
  498.     pw_repairretained(topruler_pixwin);
  499.     pw_donedamaged(topruler_pixwin);
  500.     }
  501.  
  502. int
  503. init_topruler(tool)
  504. TOOL        tool;
  505. {
  506.     INPUTMASK        mask;
  507.  
  508.     topruler_sw = tool_createsubwindow(tool, "top ruler", 
  509.                 TOPRULER_WIDTH, TOPRULER_HEIGHT);
  510.     if (topruler_sw == (TOOLSW)0) return(0);
  511.     (int) topruler_sw->ts_data = trswfd = topruler_sw->ts_windowfd;
  512.  
  513.     topruler_pixwin = pw_open(trswfd);
  514.     topruler_pixwin->pw_prretained = mem_create(TOPRULER_WIDTH, 
  515.                         TOPRULER_HEIGHT, 1);
  516.     topruler_sw->ts_io.tio_selected = flush_input;
  517.     input_imnull(&mask);
  518.     win_setinputcodebit(&mask, MS_RIGHT);
  519.     win_setinputmask(trswfd, &mask, NULL, WIN_NULLLINK);
  520.     win_setcursor(srswfd, &bull_cursor);
  521.     topruler_sw->ts_io.tio_handlesigwinch = topruler_sighandler;
  522.     topruler_sw->ts_destroy = null_proc;
  523.  
  524.     show_topruler();
  525.     return(1);
  526.     }
  527. #endif AMIGA
  528. #else
  529. int init_topruler(tool)
  530.     TOOL        tool;
  531. {
  532.     ruler_args[2].value = TOPRULER_WIDTH = CANVAS_WIDTH;;
  533.     ruler_args[3].value = TOPRULER_HEIGHT = RULER_WIDTH;
  534.     ruler_args[5].value = (XtArgVal)panel_sw;
  535.     ruler_args[7].value = (XtArgVal)NULL;
  536.     /* fix the top & bottom to the top of the form,
  537.        the left to the panel, and the right is rubber */
  538.     ruler_args[10].value = (XtArgVal)XtChainTop;
  539.     ruler_args[11].value = (XtArgVal)XtChainTop;
  540.     ruler_args[12].value = (XtArgVal)XtRubber;
  541.     ruler_args[13].value = (XtArgVal)XtRubber;
  542.     
  543.     topruler_sw = XtCreateWidget("truler", labelWidgetClass, tool,
  544.         ruler_args, XtNumber(ruler_args));
  545.     return(1);
  546. }
  547.  
  548. redisplay_topruler()
  549. {
  550.     XClearWindow(tool_d, topruler_pixwin);
  551. }
  552. #endif    X11
  553.  
  554. #ifndef    X11
  555. #ifdef AMIGA
  556. #else
  557. show_topruler()
  558. {
  559.     int     i, qinch, len, sinch, charwid;
  560.     char    **d;
  561.  
  562.     pw_writebackground(topruler_pixwin, 0, 0, 2048, 2048, PAINT);
  563.  
  564.     charwid = char_width(bold_font);
  565.     len = RULER_WIDTH - INCH_MARK;
  566.     for (d = number, d++, i = PIX_PER_INCH - charwid / 2; 
  567.         i < CANVAS_WIDTH; 
  568.         d++, i += PIX_PER_INCH) {
  569.         pw_text(topruler_pixwin, i, len, PAINT, bold_font, *d);
  570.         }
  571.     qinch = PIX_PER_INCH / 4;
  572.     sinch = PIX_PER_INCH / 16;
  573.     /*  Draw Scale  */
  574.     len = RULER_WIDTH - INCH_MARK;
  575.     for (i = -1; i < CANVAS_WIDTH; i += PIX_PER_INCH)
  576.         pw_vector(topruler_pixwin, i, RULER_WIDTH, i, len, PAINT, 1);
  577.     len = RULER_WIDTH - HALF_MARK;
  578.     for (i = -1; i < CANVAS_WIDTH; i += PIX_PER_INCH)
  579.         pw_vector(topruler_pixwin, i, RULER_WIDTH, i, len, PAINT, 1);
  580.     len = RULER_WIDTH - QUARTER_MARK;
  581.     for (i = -1; i < CANVAS_WIDTH; i += qinch)
  582.         pw_vector(topruler_pixwin, i, RULER_WIDTH, i, len, PAINT, 1);
  583.     len = RULER_WIDTH - SIXTEENTH_MARK;
  584.     for (i = -1; i < CANVAS_WIDTH; i += sinch)
  585.         pw_vector(topruler_pixwin, i, RULER_WIDTH, i, len, PAINT, 1);
  586.     /*  Darw marker  */
  587.     pw_write(topruler_pixwin, lastx + troffx, RULER_WIDTH + troffy, 
  588.         TRM_WID, TRM_HT, INV_PAINT, &trm_pr, 0, 0);
  589.     }
  590. #endif
  591. #endif    X11
  592.  
  593. set_rulermark(x, y)
  594. int    x, y;
  595. {
  596.     if( TRACKING )
  597.     {
  598.         set_siderulermark(y);
  599.         set_toprulermark(x);
  600.     }
  601. }
  602.  
  603. #ifdef    X11
  604. redisplay_rulers()
  605. {
  606.     redisplay_topruler();
  607.     redisplay_sideruler();
  608. }
  609. #endif
  610.  
  611. #ifdef AMIGA
  612. #else
  613. set_siderulermark(y)
  614. int    y;
  615. {
  616.     int    sy;
  617.  
  618. #ifndef    X11
  619.     sy = SIDERULER_START + y;
  620.     if (RHS_PANEL) { /*  side ruler is on the LSH of canvas */
  621.         pw_write(sideruler_pixwin, RULER_WIDTH+srloffx, lasty+srloffy, 
  622.             SRM_WID, SRM_HT, INV_PAINT, &srlm_pr, 0, 0);
  623.         pw_write(sideruler_pixwin, RULER_WIDTH+srloffx, sy+srloffy, 
  624.             SRM_WID, SRM_HT, INV_PAINT, &srlm_pr, 0, 0);
  625.         }
  626.     else { /*  side ruler is on the RSH of canvas */
  627.         pw_write(sideruler_pixwin, srroffx, lasty+srroffy, 
  628.             SRM_WID, SRM_HT, INV_PAINT, &srrm_pr, 0, 0);
  629.         pw_write(sideruler_pixwin, srroffx, sy+srroffy, 
  630.             SRM_WID, SRM_HT, INV_PAINT, &srrm_pr, 0, 0);
  631.         }
  632.     lasty = sy;
  633. #else
  634.     if( RHS_PANEL ) {
  635.         /* Because the ruler uses a background pixmap, we can win
  636.            here by using XClearArea to erase the old thing. */
  637.         XClearArea(tool_d, sideruler_pixwin,
  638.                RULER_WIDTH+srloffx, lasty + srloffy,
  639.                srlm_pr.width, srlm_pr.height, False);
  640.         XCopyArea(tool_d, sidearrow_pm, sideruler_pixwin,
  641.               sidegc, 0, 0, srlm_pr.width,
  642.               srlm_pr.height, RULER_WIDTH+srloffx, y + srloffy);
  643.     }
  644.     else
  645.     {
  646.         /* Because the ruler uses a background pixmap, we can win
  647.            here by using XClearArea to erase the old thing. */
  648.         XClearArea(tool_d, sideruler_pixwin,
  649.                srroffx, lasty + srroffy,
  650.                srlm_pr.width, srlm_pr.height, False);
  651.         XCopyArea(tool_d, sidearrow_pm, sideruler_pixwin,
  652.               sidegc, 0, 0, srrm_pr.width,
  653.               srrm_pr.height, srroffx, y + srroffy);
  654.     }
  655.     lasty = y;
  656. #endif    X11
  657. }
  658. #endif
  659.